.TH std::mdspan::mdspan 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::mdspan::mdspan \- std::mdspan::mdspan

.SH Synopsis
   constexpr mdspan();                                               \fB(1)\fP  (since C++23)
   template< class... OtherIndexTypes >
       constexpr explicit mdspan( data_handle_type p,                \fB(2)\fP  (since C++23)
   OtherIndexTypes... exts );
   template< class OtherIndexType, std::size_t N >

       constexpr explicit(N != rank_dynamic())                       \fB(3)\fP  (since C++23)

           mdspan( data_handle_type p, std::span<OtherIndexType, N>
   exts );
   template< class OtherIndexType, std::size_t N >

       constexpr explicit(N != rank_dynamic())                       \fB(4)\fP  (since C++23)

           mdspan( data_handle_type p, const
   std::array<OtherIndexType, N>& exts );
   constexpr mdspan( data_handle_type p, const extents_type& ext );  \fB(5)\fP  (since C++23)
   constexpr mdspan( data_handle_type p, const mapping_type& m );    \fB(6)\fP  (since C++23)
   constexpr mdspan( data_handle_type p, const mapping_type& m,      \fB(7)\fP  (since C++23)
                     const accessor_type& a );
   template< class OtherElementType, class OtherExtents,

             class OtherLayoutPolicy, class OtherAccessor >
       constexpr explicit(/* see below */)                           \fB(8)\fP  (since C++23)
           mdspan( const mdspan<OtherElementType, OtherExtents,

                                OtherLayoutPolicy, OtherAccessor>&
   other );
   constexpr mdspan( const mdspan& rhs ) = default;                  \fB(9)\fP  (since C++23)
   constexpr mdspan( mdspan&& rhs ) = default;                       \fB(10)\fP (since C++23)

   Constructs an mdspan, optionally using user-supplied data handle p, layout mapping
   m, and accessor a. If extents exts or ext are supplied, they are converted to
   extents_type and used to initialize the layout mapping.

   1) Constructs an empty mdspan. Value-initializes ptr_, map_, and acc_.
     * The behavior is undefined if [0, map_.required_span_size()) is not an accessible
       range of ptr_ and acc_ for the values of map_ and acc_ after the invocation of
       this constructor.
     * This overload participates in overload resolution only if

     * rank_dynamic() > 0 is true,
     * std::is_default_constructible_v<data_handle_type> is true,
     * std::is_default_constructible_v<mapping_type> is true, and
     * std::is_default_constructible_v<accessor_type> is true.
   2) Constructs an mdspan over the underlying data referred by p with extents
   represented by exts.... Value-initializes acc_, direct-non-list-initializes ptr_
   with std::move(p) and map_ with
   extents_type(static_cast<index_type>(std::move(exts))...).
     * The behavior is undefined if [0, map_.required_span_size()) is not an accessible
       range of ptr_ and acc_ for the values of map_ and acc_ after the invocation of
       this constructor.
     * Let N be sizeof...(OtherIndexTypes). This overload participates in overload
       resolution only if

     * (std::is_convertible_v<OtherIndexTypes, index_type> && ...) is true,
     * (std::is_nothrow_constructible<index_type, OtherIndexTypes> && ...) is true,
     * N == rank() || N == rank_dynamic() is true,
     * std::is_constructible_v<mapping_type, extents_type> is true, and
     * std::is_default_constructible_v<accessor_type> is true.
   3,4) Constructs an mdspan over the underlying data referred by p with extents
   represented by pack exts. Value-initializes acc_, direct-non-list-initializes ptr_
   with std::move(p) and map_ with extents_type(exts).
     * The behavior is undefined if [0, map_.required_span_size()) is not an accessible
       range of ptr_ and acc_ for the values of map_ and acc_ after the invocation of
       this constructor.
     * This overload participates in overload resolution only if

     * std::is_convertible_v<const OtherIndexTypes&, index_type> is true,
     * std::is_nothrow_constructible<index_type, const OtherIndexTypes&> is true,
     * N == rank() || N == rank_dynamic() is true,
     * std::is_constructible_v<mapping_type, extents_type> is true, and
     * std::is_default_constructible_v<accessor_type> is true.
   5) Constructs an mdspan over the underlying data referred by p with extents
   represented by ext. Value-initializes acc_, direct-non-list-initializes ptr_ with
   std::move(p) and map_ with exts.
     * The behavior is undefined if [0, map_.required_span_size()) is not an accessible
       range of p and acc_ for the values of map_ and acc_ after the invocation of this
       constructor.
     * This overload participates in overload resolution only if

     * std::is_constructible_v<mapping_type, const mapping_type&> is true, and
     * std::is_default_constructible_v<accessor_type> is true.
   6) Constructs an mdspan over the underlying data referred by p with layout mapping
   m. Value-initializes acc_, direct-non-list-initializes ptr_ with std::move(p) and
   map_ with m.
     * The behavior is undefined if [0, m.required_span_size()) is not an accessible
       range of p and acc_ for the values of acc_ after the invocation of this
       constructor.
     * This overload participates in overload resolution only if
       std::is_default_constructible_v<accessor_type> is true.
   7) Constructs an mdspan over the underlying data referred by p with layout mapping m
   and accessor a. Direct-non-list-initializes ptr_ with std::move(p), map_ with m and
   acc_ with a.
     * The behavior is undefined if [0, m.required_span_size()) is not an accessible
       range of p and a after the invocation of this constructor.
   8) Converting constructor from another mdspan. Direct-non-list-initializes ptr_ with
   other.ptr_, map_ with other.map_ and acc_ with other.acc_.
     * The behavior is undefined if :

     * [0, map_.required_span_size()) is not an accessible range of ptr_ and acc_ for
       the values of map_ and acc_ after the invocation of this constructor, or
     * for each rank index r of extents_type,    extents_type::static_extent(r) ==
       std::dynamic_extent
       || extents_type::static_extent(r) == other.extent(r) is false.
     * This overload participates in overload resolution only if

     * std::is_constructible_v<mapping_type, const OtherLayoutPolicy::
           template mapping<OtherExtents>&> is true, and
     * std::is_constructible_v<accessor_type, const OtherAccessor&> is true.
     * The program is ill-formed if:

     * std::is_constructible_v<data_handle_type,
           const OtherAccessor::data_handle_type&> is false, or
     * std::is_constructible_v<extents_type, OtherExtents> is false.
     * The expression inside explicit is equivalent to:    !std::is_convertible_v<const
       OtherLayoutPolicy::
              template mapping<OtherExtents>&, mapping_type>
       || !std::is_convertible_v<const OtherAccessor&, accessor_type>
   9) Defaulted copy constructor.
   10) Defaulted move constructor.

.SH Parameters

   p     - a handle to the underlying data
   m     - a layout mapping
   a     - an accessor
   ext   - a std::extents object
   exts  - represents a multi-dimensional extents
   other - another mdspan to convert from
   rhs   - another mdspan to copy or move from

.SH Example

    This section is incomplete
    Reason: no example

.SH References

     * C++23 standard (ISO/IEC 14882:2023):

     * 24.7.3.6.2 Constructors [mdspan.mdspan.cons]

.SH See also

    This section is incomplete

.SH Categories:
     * Todo no example
     * Todo without reason
